//package io.github.zatter.qiniucorejava.utils;
//
//import com.fasterxml.jackson.databind.JsonNode;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.fasterxml.jackson.databind.node.ArrayNode;
//import com.fasterxml.jackson.databind.node.ObjectNode;
//import com.qiniu.common.QiniuException;
//import io.github.zatter.qiniucorejava.mapper.AiMapper;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.http.*;
//import org.springframework.scheduling.annotation.Scheduled;
//import org.springframework.stereotype.Component;
//import org.springframework.web.client.RestTemplate;
//import org.springframework.web.multipart.MultipartFile;
//
//import java.time.Duration;
//import java.util.LinkedList;
//import java.util.Queue;
//import java.util.concurrent.CopyOnWriteArrayList;
//
////语音转文字->AI识别->文字转语音
//@Slf4j
//@Component
//public class TextProcessing {
//    // 模型配置
//    private static final String API_KEY = "sk-610453bad9743dfb294ae3234ada68874c4c1640e6c4cd716dfac043a774eb21";
//    private static final String BASE_URL = "https://openai.qiniu.com/v1"; // 主地址
//    private static final String MODEL_ID = "x-ai/grok-4-fast";
//    private final RestTemplate restTemplate;
//    private final ObjectMapper objectMapper;
//
//    @Autowired
//    AiMapper aiMapper;
//
//    // 上下文最大消息数量
//    private static final int MAX_CONTEXT_MESSAGES = 20;
//
//    // 存储上下文消息，使用Queue实现FIFO机制
//    // 每条消息是一个包含"role"和"content"的ObjectNode
//    private final Queue<ObjectNode> contextMessages = new LinkedList<>();
//
//    // 初始化RestTemplate和ObjectMapper
//    public TextProcessing() {
//        this.restTemplate = new RestTemplate();
//        this.objectMapper = new ObjectMapper();
//
//        // 配置超时
//        ((org.springframework.http.client.SimpleClientHttpRequestFactory) restTemplate.getRequestFactory())
//                .setConnectTimeout(Duration.ofSeconds(30));
//        ((org.springframework.http.client.SimpleClientHttpRequestFactory) restTemplate.getRequestFactory())
//                .setReadTimeout(Duration.ofSeconds(60));
//    }
//
//    /**
//     * 处理语音文件：通过chat/completions接口发送JSON格式请求
//     */
//    public String processText(String text, String prompt) {
//
//        //首先校验角色有没有发生变化
//        String role = aiMapper.GetSetting("ai_role");
//        if(role == null) {
//            //如果当前用户没有角色 则直接添加
//            aiMapper.UpdateSetting("ai_role", prompt);
//        }
//        else if(!role.equals(prompt)) {
//            //如果用户角色改变 则改变数据库+清空上下文
//            aiMapper.UpdateSetting("ai_role", prompt);
//            contextMessages.clear();
//            log.info("角色改变，清空上下文");
//        }
//
//        try {
//
//            // 将用户消息添加到上下文
//            addToContext("user", text);
//
//            // 4. 构建请求头
//            HttpHeaders headers = new HttpHeaders();
//            headers.set("Authorization", "Bearer " + API_KEY);
//            headers.setContentType(MediaType.APPLICATION_JSON);
//
//            // 5. 构建请求体JSON
//            ObjectNode requestBody = objectMapper.createObjectNode();
//            requestBody.put("stream", false);
//            requestBody.put("model", MODEL_ID);
//
//            // 构建messages数组
//            ArrayNode messages = objectMapper.createArrayNode();
//
//            // 添加system消息
//            ObjectNode systemMessage = objectMapper.createObjectNode();
//            systemMessage.put("role", "system");
//            //指定角色
//            systemMessage.put("content", "你现在是"+prompt+"，请使用中文和我聊天吧，注意你是吕布，你谁也不是");
//            messages.add(systemMessage);
//
//            // 添加上下文消息
//            contextMessages.forEach(messages::add);
//
//            requestBody.set("messages", messages);
//
//            // 6. 构建完整请求
//            HttpEntity<String> request = new HttpEntity<>(
//                    objectMapper.writeValueAsString(requestBody),
//                    headers
//            );
//
//            // 7. 调用chat/completions接口
//            String apiUrl = BASE_URL + "/chat/completions";
////            log.info("调用接口：{}，文件：{}，大小：{}MB", apiUrl, audioFile.getOriginalFilename(), fileSizeMB);
//
//            // 发送POST请求并获取响应
//            ResponseEntity<String> response = restTemplate.postForEntity(apiUrl, request, String.class);
//
//            // 8. 处理响应
//            if (response.getStatusCode() == HttpStatus.OK) {
//                String responseBody = response.getBody();
//                if (responseBody != null) {
//                    // 解析响应获取结果
//                    JsonNode jsonNode = objectMapper.readTree(responseBody);
//                    String result = jsonNode.path("choices").get(0).path("message").path("content").asText();
//                    log.info("大模型处理成功，结果：{}", result);
//
//                    // 将AI回复添加到上下文
//                    addToContext("assistant", result);
//                    return  result;
//                }
//                return "处理成功，但未返回内容";
//            } else {
//                return "错误：模型返回非成功状态码 " + response.getStatusCode() + "，响应内容：" + response.getBody();
//            }
//
//        } catch (Exception e) {
//            log.error("音频处理失败", e);
//            String errorMsg = e.getMessage();
//            if (e instanceof org.springframework.web.client.HttpClientErrorException) {
//                String responseBody = ((org.springframework.web.client.HttpClientErrorException) e).getResponseBodyAsString();
//                errorMsg += "，响应详情：" + responseBody;
//            }
//            return "处理语音时发生错误：" + errorMsg;
//        }
//    }
//
//    /**
//     * 添加消息到上下文，并确保不超过最大数量限制
//     */
//    private void addToContext(String role, String content) {
//        ObjectNode message = objectMapper.createObjectNode();
//        message.put("role", role);
//        message.put("content", content);
//
//        // 添加新消息
//        contextMessages.add(message);
//
//        // 如果超过最大限制，移除最旧的消息
//        while (contextMessages.size() > MAX_CONTEXT_MESSAGES) {
//            contextMessages.poll(); // 移除队列头部的消息（最旧的）
//        }
//
//        log.info("上下文消息数量: {}", contextMessages.size());
//    }
//}
package io.github.zatter.qiniucorejava.utils;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.zatter.qiniucorejava.mapper.AiMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.IOException;
import java.time.Duration;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
@Component
public class TextProcessing {
    // 模型配置
    private static final String API_KEY = "sk-610453bad9743dfb294ae3234ada68874c4c1640e6c4cd716dfac043a774eb21";
    private static final String BASE_URL = "https://openai.qiniu.com/v1"; // 主地址
    private static final String MODEL_ID = "x-ai/grok-4-fast";
    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper;
    private final ExecutorService executorService = Executors.newCachedThreadPool();

    @Autowired
    AiMapper aiMapper;

    // 上下文最大消息数量
    private static final int MAX_CONTEXT_MESSAGES = 20;

    // 使用线程安全的Map存储每个用户的上下文，key可以是用户ID或会话ID
    private final CopyOnWriteArrayList<UserContext> userContexts = new CopyOnWriteArrayList<>();

    // 初始化RestTemplate和ObjectMapper
    public TextProcessing() {
        this.restTemplate = new RestTemplate();
        this.objectMapper = new ObjectMapper();

        // 配置超时
        ((org.springframework.http.client.SimpleClientHttpRequestFactory) restTemplate.getRequestFactory())
                .setConnectTimeout(Duration.ofSeconds(30));
        ((org.springframework.http.client.SimpleClientHttpRequestFactory) restTemplate.getRequestFactory())
                .setReadTimeout(Duration.ofSeconds(60));
    }

    /**
     * 处理文本并通过SSE流式返回结果
     */
    public SseEmitter processTextStream(String userId, String text, String prompt) {
        // 创建SSE发射器，设置超时时间（3分钟）
        SseEmitter emitter = new SseEmitter(180_000L);

        // 为每个请求创建一个线程处理
        executorService.execute(() -> {
            try {
                // 获取或创建用户上下文
                UserContext userContext = getUserContext(userId);

                // 校验角色是否变化
                String role = aiMapper.GetSetting("ai_role");
                if (role == null) {
                    aiMapper.UpdateSetting("ai_role", prompt);
                } else if (!role.equals(prompt)) {
                    aiMapper.UpdateSetting("ai_role", prompt);
                    userContext.getContextMessages().clear();
                    log.info("[{}]角色改变，清空上下文", prompt);
                }

                // 将用户消息添加到上下文
                userContext.addToContext("user", text);

                // 构建请求头
                HttpHeaders headers = new HttpHeaders();
                headers.set("Authorization", "Bearer " + API_KEY);
                headers.setContentType(MediaType.APPLICATION_JSON);

                // 构建请求体JSON（开启流式输出）
                ObjectNode requestBody = objectMapper.createObjectNode();
                requestBody.put("stream", true);  // 关键：开启流式响应
                requestBody.put("model", MODEL_ID);

                // 构建messages数组
                ArrayNode messages = objectMapper.createArrayNode();

                // 添加system消息
                ObjectNode systemMessage = objectMapper.createObjectNode();
                systemMessage.put("role", "system");
                systemMessage.put("content", "你现在是" + prompt + "，请使用中文和我聊天吧");
                messages.add(systemMessage);

                // 添加上下文消息
                userContext.getContextMessages().forEach(messages::add);

                requestBody.set("messages", messages);

                // 构建完整请求
                HttpEntity<String> request = new HttpEntity<>(
                        objectMapper.writeValueAsString(requestBody),
                        headers
                );

                // 调用chat/completions接口并处理流式响应
                String apiUrl = BASE_URL + "/chat/completions";
                log.info("用户[{}]调用流式接口：{}", userId, apiUrl);

                // 使用RestTemplate的execute方法处理流式响应
                restTemplate.execute(apiUrl, HttpMethod.POST,
                        requestCallback -> {
                            // 设置请求头和 body
                            HttpHeaders headers1 = requestCallback.getHeaders();
                            headers1.putAll(request.getHeaders());
                            requestCallback.getBody().write(request.getBody().getBytes());
                        },
                        response -> {
                            // 处理响应流
                            StringBuilder fullResponse = new StringBuilder();
                            try (java.io.BufferedReader reader = new java.io.BufferedReader(
                                    new java.io.InputStreamReader(response.getBody()))) {

                                String line;
                                // 读取流中的每一行
                                while ((line = reader.readLine()) != null) {
                                    // SSE格式通常以"data:"开头
                                    if (line.isEmpty() || line.equals("data: [DONE]")) {
                                        continue;
                                    }

                                    if (line.startsWith("data: ")) {
                                        String json = line.substring("data: ".length());

                                        // 解析JSON获取增量内容
                                        JsonNode jsonNode = objectMapper.readTree(json);
                                        JsonNode choice = jsonNode.path("choices").get(0);
                                        String delta = choice.path("delta").path("content").asText();

                                        if (!delta.isEmpty()) {
                                            fullResponse.append(delta);
                                            // 发送增量内容到客户端
                                            emitter.send(SseEmitter.event()
                                                    .data(delta)
                                                    .name("message"));

                                            // 模拟打字机效果，增加微小延迟
                                            Thread.sleep(50);
                                        }
                                    }
                                }

                                // 流结束，发送完成信号
                                emitter.send(SseEmitter.event()
                                        .data("COMPLETE")
                                        .name("complete"));

                                // 将完整响应添加到上下文
                                userContext.addToContext("assistant", fullResponse.toString());
                            } catch (Exception e) {
                                log.error("处理流式响应出错", e);
                                emitter.send(SseEmitter.event()
                                        .data("错误：" + e.getMessage())
                                        .name("error"));
                            } finally {
                                emitter.complete();
                            }
                            return null;
                        }
                );

            } catch (Exception e) {
                log.error("文本流式处理失败", e);
                try {
                    emitter.send(SseEmitter.event()
                            .data("处理失败：" + e.getMessage())
                            .name("error"));
                    emitter.completeWithError(e);
                } catch (IOException ex) {
                    log.error("发送错误消息失败", ex);
                }
            }
        });

        return emitter;
    }

    /**
     * 获取用户上下文，如果不存在则创建
     */
    private UserContext getUserContext(String userId) {
        // 查找现有上下文
        for (UserContext context : userContexts) {
            if (context.getUserId().equals(userId)) {
                return context;
            }
        }

        // 创建新的用户上下文
        UserContext newContext = new UserContext(userId);
        userContexts.add(newContext);
        return newContext;
    }

    /**
     * 用户上下文类，存储每个用户的对话历史
     */
    private static class UserContext {
        private final String userId;
        private final Queue<ObjectNode> contextMessages = new LinkedList<>();

        public UserContext(String userId) {
            this.userId = userId;
        }

        public String getUserId() {
            return userId;
        }

        public Queue<ObjectNode> getContextMessages() {
            return contextMessages;
        }

        /**
         * 添加消息到上下文，并确保不超过最大数量限制
         */
        public void addToContext(String role, String content) {
            ObjectNode message = new ObjectMapper().createObjectNode();
            message.put("role", role);
            message.put("content", content);

            // 添加新消息
            contextMessages.add(message);

            // 如果超过最大限制，移除最旧的消息
            while (contextMessages.size() > MAX_CONTEXT_MESSAGES) {
                contextMessages.poll(); // 移除队列头部的消息（最旧的）
            }

            log.info("用户[{}]上下文消息数量: {}", userId, contextMessages.size());
        }
    }
}
